home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / flash-0.4.3 / plugin / npupp.h < prev    next >
C/C++ Source or Header  |  1999-01-01  |  32KB  |  996 lines
  1. /* -*- Mode: C; tab-width: 4; -*- */
  2. /*
  3.  *  npupp.h $Revision: 1.37 $
  4.  *  function call mecahnics needed by platform specific glue code.
  5.  */
  6.  
  7.  
  8. #ifndef _NPUPP_H_
  9. #define _NPUPP_H_
  10.  
  11. #ifndef GENERATINGCFM
  12. #define GENERATINGCFM 0
  13. #endif
  14.  
  15. #ifndef _NPAPI_H_
  16. #include "npapi.h"
  17. #endif
  18.  
  19. #include "jri.h"
  20.  
  21. /******************************************************************************************
  22.    plug-in function table macros
  23.              for each function in and out of the plugin API we define
  24.                     typedef NPP_FooUPP
  25.                     #define NewNPP_FooProc
  26.                     #define CallNPP_FooProc
  27.             for mac, define the UPP magic for PPC/68K calling
  28.  *******************************************************************************************/
  29.  
  30.  
  31. /* NPP_Initialize */
  32.  
  33. #if GENERATINGCFM
  34. typedef UniversalProcPtr NPP_InitializeUPP;
  35.  
  36. enum {
  37.     uppNPP_InitializeProcInfo = kThinkCStackBased
  38.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))        
  39.         | RESULT_SIZE(SIZE_CODE(0))
  40. };
  41.  
  42. #define NewNPP_InitializeProc(FUNC)        \
  43.         (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture())
  44. #define CallNPP_InitializeProc(FUNC)        \
  45.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo)
  46.         
  47. #else
  48.  
  49. typedef void (*NPP_InitializeUPP)(void);
  50. #define NewNPP_InitializeProc(FUNC)        \
  51.         ((NPP_InitializeUPP) (FUNC))
  52. #define CallNPP_InitializeProc(FUNC)        \
  53.         (*(FUNC))()
  54.  
  55. #endif
  56.  
  57.  
  58. /* NPP_Shutdown */
  59.  
  60. #if GENERATINGCFM
  61. typedef UniversalProcPtr NPP_ShutdownUPP;
  62.  
  63. enum {
  64.     uppNPP_ShutdownProcInfo = kThinkCStackBased
  65.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0))        
  66.         | RESULT_SIZE(SIZE_CODE(0))
  67. };
  68.  
  69. #define NewNPP_ShutdownProc(FUNC)        \
  70.         (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture())
  71. #define CallNPP_ShutdownProc(FUNC)        \
  72.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo)
  73.         
  74. #else
  75.  
  76. typedef void (*NPP_ShutdownUPP)(void);
  77. #define NewNPP_ShutdownProc(FUNC)        \
  78.         ((NPP_ShutdownUPP) (FUNC))
  79. #define CallNPP_ShutdownProc(FUNC)        \
  80.         (*(FUNC))()
  81.  
  82. #endif
  83.  
  84.  
  85. /* NPP_New */
  86.  
  87. #if GENERATINGCFM
  88. typedef UniversalProcPtr NPP_NewUPP;
  89.  
  90. enum {
  91.     uppNPP_NewProcInfo = kThinkCStackBased
  92.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType)))
  93.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP)))
  94.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16)))
  95.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16)))
  96.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **)))
  97.         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **)))
  98.         | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *)))
  99.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  100. };
  101.  
  102. #define NewNPP_NewProc(FUNC)        \
  103.         (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture())
  104. #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
  105.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \
  106.                                    (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
  107. #else
  108.  
  109. typedef NPError    (*NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved);
  110. #define NewNPP_NewProc(FUNC)        \
  111.         ((NPP_NewUPP) (FUNC))
  112. #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7)        \
  113.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
  114.  
  115. #endif
  116.  
  117.  
  118. /* NPP_Destroy */
  119.  
  120. #if GENERATINGCFM
  121.  
  122. typedef UniversalProcPtr NPP_DestroyUPP;
  123. enum {
  124.     uppNPP_DestroyProcInfo = kThinkCStackBased
  125.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  126.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **)))
  127.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  128. };
  129. #define NewNPP_DestroyProc(FUNC)        \
  130.         (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture())
  131. #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)        \
  132.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2))
  133. #else
  134.  
  135. typedef NPError    (*NPP_DestroyUPP)(NPP instance, NPSavedData** save);
  136. #define NewNPP_DestroyProc(FUNC)        \
  137.         ((NPP_DestroyUPP) (FUNC))
  138. #define CallNPP_DestroyProc(FUNC, ARG1, ARG2)        \
  139.         (*(FUNC))((ARG1), (ARG2))
  140.  
  141. #endif
  142.  
  143.  
  144. /* NPP_SetWindow */
  145.  
  146. #if GENERATINGCFM
  147.  
  148. typedef UniversalProcPtr NPP_SetWindowUPP;
  149. enum {
  150.     uppNPP_SetWindowProcInfo = kThinkCStackBased
  151.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  152.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *)))
  153.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  154. };
  155. #define NewNPP_SetWindowProc(FUNC)        \
  156.         (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture())
  157. #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)        \
  158.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2))
  159.  
  160. #else
  161.  
  162. typedef NPError    (*NPP_SetWindowUPP)(NPP instance, NPWindow* window);
  163. #define NewNPP_SetWindowProc(FUNC)        \
  164.         ((NPP_SetWindowUPP) (FUNC))
  165. #define CallNPP_SetWindowProc(FUNC, ARG1, ARG2)        \
  166.         (*(FUNC))((ARG1), (ARG2))
  167.  
  168. #endif
  169.  
  170.  
  171. /* NPP_NewStream */
  172.  
  173. #if GENERATINGCFM
  174.  
  175. typedef UniversalProcPtr NPP_NewStreamUPP;
  176. enum {
  177.     uppNPP_NewStreamProcInfo = kThinkCStackBased
  178.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  179.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
  180.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *)))
  181.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool)))
  182.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *)))
  183.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  184. };
  185. #define NewNPP_NewStreamProc(FUNC)        \
  186.         (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture())
  187. #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5)        \
  188.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
  189. #else
  190.  
  191. typedef NPError    (*NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype);
  192. #define NewNPP_NewStreamProc(FUNC)        \
  193.         ((NPP_NewStreamUPP) (FUNC))
  194. #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \
  195.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5))
  196. #endif
  197.  
  198.  
  199. /* NPP_DestroyStream */
  200.  
  201. #if GENERATINGCFM
  202.  
  203. typedef UniversalProcPtr NPP_DestroyStreamUPP;
  204. enum {
  205.     uppNPP_DestroyStreamProcInfo = kThinkCStackBased
  206.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  207.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  208.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
  209.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  210. };
  211. #define NewNPP_DestroyStreamProc(FUNC)        \
  212.         (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture())
  213. #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)        \
  214.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg))
  215.  
  216. #else
  217.  
  218. typedef NPError    (*NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
  219. #define NewNPP_DestroyStreamProc(FUNC)        \
  220.         ((NPP_DestroyStreamUPP) (FUNC))
  221. #define CallNPP_DestroyStreamProc(FUNC,  NPParg, NPStreamPtr, NPReasonArg)        \
  222.         (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg))
  223.  
  224. #endif
  225.  
  226.  
  227. /* NPP_WriteReady */
  228.  
  229. #if GENERATINGCFM
  230.  
  231. typedef UniversalProcPtr NPP_WriteReadyUPP;
  232. enum {
  233.     uppNPP_WriteReadyProcInfo = kThinkCStackBased
  234.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  235.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  236.         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
  237. };
  238. #define NewNPP_WriteReadyProc(FUNC)        \
  239.         (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture())
  240. #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)        \
  241.         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr))
  242.  
  243. #else
  244.  
  245. typedef int32 (*NPP_WriteReadyUPP)(NPP instance, NPStream* stream);
  246. #define NewNPP_WriteReadyProc(FUNC)        \
  247.         ((NPP_WriteReadyUPP) (FUNC))
  248. #define CallNPP_WriteReadyProc(FUNC,  NPParg, NPStreamPtr)        \
  249.         (*(FUNC))((NPParg), (NPStreamPtr))
  250.  
  251. #endif
  252.  
  253.  
  254. /* NPP_Write */
  255.  
  256. #if GENERATINGCFM
  257.  
  258. typedef UniversalProcPtr NPP_WriteUPP;
  259. enum {
  260.     uppNPP_WriteProcInfo = kThinkCStackBased
  261.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  262.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  263.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
  264.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32)))
  265.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*)))
  266.         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
  267. };
  268. #define NewNPP_WriteProc(FUNC)        \
  269.         (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture())
  270. #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)        \
  271.         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
  272.  
  273. #else
  274.  
  275. typedef int32 (*NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer);
  276. #define NewNPP_WriteProc(FUNC)        \
  277.         ((NPP_WriteUPP) (FUNC))
  278. #define CallNPP_WriteProc(FUNC,  NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr)        \
  279.         (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr))
  280.  
  281. #endif
  282.  
  283.  
  284. /* NPP_StreamAsFile */
  285.  
  286. #if GENERATINGCFM
  287.  
  288. typedef UniversalProcPtr NPP_StreamAsFileUPP;
  289. enum {
  290.     uppNPP_StreamAsFileProcInfo = kThinkCStackBased
  291.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  292.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  293.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
  294.         | RESULT_SIZE(SIZE_CODE(0))
  295. };
  296. #define NewNPP_StreamAsFileProc(FUNC)        \
  297.         (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture())
  298. #define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3)        \
  299.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3))
  300.  
  301. #else
  302.  
  303. typedef void (*NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname);
  304. #define NewNPP_StreamAsFileProc(FUNC)        \
  305.         ((NPP_StreamAsFileUPP) (FUNC))
  306. #define CallNPP_StreamAsFileProc(FUNC,  ARG1, ARG2, ARG3)        \
  307.         (*(FUNC))((ARG1), (ARG2), (ARG3))
  308. #endif
  309.  
  310.  
  311. /* NPP_Print */
  312.  
  313. #if GENERATINGCFM
  314.  
  315. typedef UniversalProcPtr NPP_PrintUPP;
  316. enum {
  317.     uppNPP_PrintProcInfo = kThinkCStackBased
  318.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  319.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *)))
  320.         | RESULT_SIZE(SIZE_CODE(0))
  321. };
  322. #define NewNPP_PrintProc(FUNC)        \
  323.         (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture())
  324. #define CallNPP_PrintProc(FUNC,  NPParg, voidPtr)        \
  325.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr))
  326.  
  327. #else
  328.  
  329. typedef void (*NPP_PrintUPP)(NPP instance, NPPrint* platformPrint);
  330. #define NewNPP_PrintProc(FUNC)        \
  331.         ((NPP_PrintUPP) (FUNC))
  332. #define CallNPP_PrintProc(FUNC,  NPParg, NPPrintArg)        \
  333.         (*(FUNC))((NPParg), (NPPrintArg))
  334.  
  335. #endif
  336.  
  337.  
  338. /* NPP_HandleEvent */
  339.  
  340. #if GENERATINGCFM
  341.  
  342. typedef UniversalProcPtr NPP_HandleEventUPP;
  343. enum {
  344.     uppNPP_HandleEventProcInfo = kThinkCStackBased
  345.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  346.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  347.         | RESULT_SIZE(SIZE_CODE(sizeof(int16)))
  348. };
  349. #define NewNPP_HandleEventProc(FUNC)        \
  350.         (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture())
  351. #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)        \
  352.         (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr))
  353.  
  354. #else
  355.  
  356. typedef int16 (*NPP_HandleEventUPP)(NPP instance, void* event);
  357. #define NewNPP_HandleEventProc(FUNC)        \
  358.         ((NPP_HandleEventUPP) (FUNC))
  359. #define CallNPP_HandleEventProc(FUNC,  NPParg, voidPtr)        \
  360.         (*(FUNC))((NPParg), (voidPtr))
  361.  
  362. #endif
  363.  
  364.  
  365. /* NPP_URLNotify */
  366.  
  367. #if GENERATINGCFM
  368.  
  369. typedef UniversalProcPtr NPP_URLNotifyUPP;
  370. enum {
  371.     uppNPP_URLNotifyProcInfo = kThinkCStackBased
  372.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  373.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
  374.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
  375.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  376.         | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0)))
  377. };
  378. #define NewNPP_URLNotifyProc(FUNC)        \
  379.         (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture())
  380. #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)        \
  381.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
  382.  
  383. #else
  384.  
  385. typedef void (*NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData);
  386. #define NewNPP_URLNotifyProc(FUNC)        \
  387.         ((NPP_URLNotifyUPP) (FUNC))
  388. #define CallNPP_URLNotifyProc(FUNC,  ARG1, ARG2, ARG3, ARG4)        \
  389.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
  390.  
  391. #endif
  392.  
  393.  
  394.  
  395.  
  396. /*
  397.  *  Netscape entry points
  398.  */
  399.  
  400. #ifdef XP_UNIX
  401.  
  402. /* NPN_GetValue */
  403.  
  404. #if GENERATINGCFM
  405.  
  406. typedef UniversalProcPtr NPN_GetValueUPP;
  407. enum {
  408.     uppNPN_GetValueProcInfo = kThinkCStackBased
  409.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  410.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable)))
  411.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  412.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  413. };
  414. #define NewNPN_GetValueProc(FUNC)        \
  415.         (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture())
  416. #define CallNPN_GetURNotifyLProc(FUNC, ARG1, ARG2, ARG3) \
  417.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3))
  418. #else
  419.  
  420. typedef NPError    (*NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue);
  421. #define NewNPN_GetValueProc(FUNC)        \
  422.         ((NPN_GetValueUPP) (FUNC))
  423. #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3)        \
  424.         (*(FUNC))((ARG1), (ARG2), (ARG3))
  425. #endif
  426.  
  427. #endif /* XP_UNIX */
  428.  
  429.  
  430.  
  431. /* NPN_GetUrlNotify */
  432.  
  433. #if GENERATINGCFM
  434.  
  435. typedef UniversalProcPtr NPN_GetURLNotifyUPP;
  436. enum {
  437.     uppNPN_GetURLNotifyProcInfo = kThinkCStackBased
  438.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  439.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
  440.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
  441.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  442.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  443. };
  444. #define NewNPN_GetURLNotifyProc(FUNC)        \
  445.         (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture())
  446. #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \
  447.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4))
  448. #else
  449.  
  450. typedef NPError    (*NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData);
  451. #define NewNPN_GetURLNotifyProc(FUNC)        \
  452.         ((NPN_GetURLNotifyUPP) (FUNC))
  453. #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4)        \
  454.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4))
  455. #endif
  456.  
  457.  
  458. /* NPN_PostUrlNotify */
  459.  
  460. #if GENERATINGCFM
  461.  
  462. typedef UniversalProcPtr NPN_PostURLNotifyUPP;
  463. enum {
  464.     uppNPN_PostURLNotifyProcInfo = kThinkCStackBased
  465.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  466.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
  467.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
  468.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
  469.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
  470.         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
  471.         | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*)))
  472.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  473. };
  474. #define NewNPN_PostURLNotifyProc(FUNC)        \
  475.         (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture())
  476. #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
  477.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
  478. #else
  479.  
  480. typedef NPError (*NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData);
  481. #define NewNPN_PostURLNotifyProc(FUNC)        \
  482.         ((NPN_PostURLNotifyUPP) (FUNC))
  483. #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \
  484.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7))
  485. #endif
  486.  
  487.  
  488. /* NPN_GetUrl */
  489.  
  490. #if GENERATINGCFM
  491.  
  492. typedef UniversalProcPtr NPN_GetURLUPP;
  493. enum {
  494.     uppNPN_GetURLProcInfo = kThinkCStackBased
  495.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  496.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
  497.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
  498.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  499. };
  500. #define NewNPN_GetURLProc(FUNC)        \
  501.         (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture())
  502. #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \
  503.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3))
  504. #else
  505.  
  506. typedef NPError    (*NPN_GetURLUPP)(NPP instance, const char* url, const char* window);
  507. #define NewNPN_GetURLProc(FUNC)        \
  508.         ((NPN_GetURLUPP) (FUNC))
  509. #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3)        \
  510.         (*(FUNC))((ARG1), (ARG2), (ARG3))
  511. #endif
  512.  
  513.  
  514. /* NPN_PostUrl */
  515.  
  516. #if GENERATINGCFM
  517.  
  518. typedef UniversalProcPtr NPN_PostURLUPP;
  519. enum {
  520.     uppNPN_PostURLProcInfo = kThinkCStackBased
  521.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  522.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*)))
  523.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*)))
  524.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32)))
  525.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*)))
  526.         | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool)))
  527.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  528. };
  529. #define NewNPN_PostURLProc(FUNC)        \
  530.         (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture())
  531. #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
  532.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
  533. #else
  534.  
  535. typedef NPError (*NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file);
  536. #define NewNPN_PostURLProc(FUNC)        \
  537.         ((NPN_PostURLUPP) (FUNC))
  538. #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
  539.         (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6))
  540. #endif
  541.  
  542.  
  543. /* NPN_RequestRead */
  544.  
  545. #if GENERATINGCFM
  546.  
  547. typedef UniversalProcPtr NPN_RequestReadUPP;
  548. enum {
  549.     uppNPN_RequestReadProcInfo = kThinkCStackBased
  550.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *)))
  551.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *)))
  552.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  553. };
  554. #define NewNPN_RequestReadProc(FUNC)        \
  555.         (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture())
  556. #define CallNPN_RequestReadProc(FUNC,  stream, range)        \
  557.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range))
  558.  
  559. #else
  560.  
  561. typedef NPError    (*NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList);
  562. #define NewNPN_RequestReadProc(FUNC)        \
  563.         ((NPN_RequestReadUPP) (FUNC))
  564. #define CallNPN_RequestReadProc(FUNC, stream, range)        \
  565.         (*(FUNC))((stream), (range))
  566.  
  567. #endif
  568.  
  569.  
  570. /* NPN_NewStream */
  571.  
  572. #if GENERATINGCFM
  573.  
  574. typedef UniversalProcPtr NPN_NewStreamUPP;
  575. enum {
  576.     uppNPN_NewStreamProcInfo = kThinkCStackBased
  577.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  578.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType)))
  579.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *)))
  580.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **)))
  581.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  582. };
  583. #define NewNPN_NewStreamProc(FUNC)        \
  584.         (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture())
  585. #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)        \
  586.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream))    
  587.  
  588. #else
  589.  
  590. typedef NPError    (*NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream);
  591. #define NewNPN_NewStreamProc(FUNC)        \
  592.         ((NPN_NewStreamUPP) (FUNC))
  593. #define CallNPN_NewStreamProc(FUNC, npp, type, window, stream)        \
  594.         (*(FUNC))((npp), (type), (window), (stream))
  595.  
  596. #endif
  597.  
  598.  
  599. /* NPN_Write */
  600.  
  601. #if GENERATINGCFM
  602.  
  603. typedef UniversalProcPtr NPN_WriteUPP;
  604. enum {
  605.     uppNPN_WriteProcInfo = kThinkCStackBased
  606.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  607.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  608.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32)))
  609.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  610.         | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
  611. };
  612. #define NewNPN_WriteProc(FUNC)        \
  613.         (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture())
  614. #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)        \
  615.         (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer))    
  616.  
  617. #else
  618.  
  619. typedef int32 (*NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer);
  620. #define NewNPN_WriteProc(FUNC)        \
  621.         ((NPN_WriteUPP) (FUNC))
  622. #define CallNPN_WriteProc(FUNC, npp, stream, len, buffer)        \
  623.         (*(FUNC))((npp), (stream), (len), (buffer))
  624.  
  625. #endif
  626.  
  627.  
  628. /* NPN_DestroyStream */
  629.  
  630. #if GENERATINGCFM
  631.  
  632. typedef UniversalProcPtr NPN_DestroyStreamUPP;
  633. enum {
  634.     uppNPN_DestroyStreamProcInfo = kThinkCStackBased
  635.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP )))
  636.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *)))
  637.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason)))
  638.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  639. };
  640. #define NewNPN_DestroyStreamProc(FUNC)        \
  641.         (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture())
  642. #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)        \
  643.         (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason))    
  644.  
  645. #else
  646.  
  647. typedef NPError (*NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason);
  648. #define NewNPN_DestroyStreamProc(FUNC)        \
  649.         ((NPN_DestroyStreamUPP) (FUNC))
  650. #define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason)        \
  651.         (*(FUNC))((npp), (stream), (reason))
  652.  
  653. #endif
  654.  
  655.  
  656. /* NPN_Status */
  657.  
  658. #if GENERATINGCFM
  659.  
  660. typedef UniversalProcPtr NPN_StatusUPP;
  661. enum {
  662.     uppNPN_StatusProcInfo = kThinkCStackBased
  663.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  664.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
  665. };
  666.  
  667. #define NewNPN_StatusProc(FUNC)        \
  668.         (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture())
  669. #define CallNPN_StatusProc(FUNC, npp, msg)        \
  670.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg))    
  671.  
  672. #else
  673.  
  674. typedef void (*NPN_StatusUPP)(NPP instance, const char* message);
  675. #define NewNPN_StatusProc(FUNC)        \
  676.         ((NPN_StatusUPP) (FUNC))
  677. #define CallNPN_StatusProc(FUNC, npp, msg)        \
  678.         (*(FUNC))((npp), (msg))    
  679.  
  680. #endif
  681.  
  682.  
  683. /* NPN_UserAgent */
  684. #if GENERATINGCFM
  685.  
  686. typedef UniversalProcPtr NPN_UserAgentUPP;
  687. enum {
  688.         uppNPN_UserAgentProcInfo = kThinkCStackBased
  689.                 | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  690.                 | RESULT_SIZE(SIZE_CODE(sizeof(const char *)))
  691. };
  692.  
  693. #define NewNPN_UserAgentProc(FUNC)              \
  694.                 (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture())
  695. #define CallNPN_UserAgentProc(FUNC, ARG1)               \
  696.                 (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1))
  697.  
  698. #else
  699.  
  700. typedef const char*    (*NPN_UserAgentUPP)(NPP instance);
  701. #define NewNPN_UserAgentProc(FUNC)              \
  702.                 ((NPN_UserAgentUPP) (FUNC))
  703. #define CallNPN_UserAgentProc(FUNC, ARG1)               \
  704.                 (*(FUNC))((ARG1))
  705.  
  706. #endif
  707.  
  708.  
  709. /* NPN_MemAlloc */
  710. #if GENERATINGCFM
  711.  
  712. typedef UniversalProcPtr NPN_MemAllocUPP;
  713. enum {
  714.     uppNPN_MemAllocProcInfo = kThinkCStackBased
  715.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
  716.         | RESULT_SIZE(SIZE_CODE(sizeof(void *)))
  717. };
  718.  
  719. #define NewNPN_MemAllocProc(FUNC)        \
  720.         (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture())
  721. #define CallNPN_MemAllocProc(FUNC, ARG1)        \
  722.         (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1))    
  723.  
  724. #else
  725.  
  726. typedef void* (*NPN_MemAllocUPP)(uint32 size);
  727. #define NewNPN_MemAllocProc(FUNC)        \
  728.         ((NPN_MemAllocUPP) (FUNC))
  729. #define CallNPN_MemAllocProc(FUNC, ARG1)        \
  730.         (*(FUNC))((ARG1))    
  731.  
  732. #endif
  733.  
  734.  
  735. /* NPN__MemFree */
  736.  
  737. #if GENERATINGCFM
  738.  
  739. typedef UniversalProcPtr NPN_MemFreeUPP;
  740. enum {
  741.     uppNPN_MemFreeProcInfo = kThinkCStackBased
  742.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *)))
  743. };
  744.  
  745. #define NewNPN_MemFreeProc(FUNC)        \
  746.         (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture())
  747. #define CallNPN_MemFreeProc(FUNC, ARG1)        \
  748.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1))
  749.  
  750. #else
  751.  
  752. typedef void (*NPN_MemFreeUPP)(void* ptr);
  753. #define NewNPN_MemFreeProc(FUNC)        \
  754.         ((NPN_MemFreeUPP) (FUNC))
  755. #define CallNPN_MemFreeProc(FUNC, ARG1)        \
  756.         (*(FUNC))((ARG1))    
  757.  
  758. #endif
  759.  
  760.  
  761. /* NPN_MemFlush */
  762.  
  763. #if GENERATINGCFM
  764.  
  765. typedef UniversalProcPtr NPN_MemFlushUPP;
  766. enum {
  767.     uppNPN_MemFlushProcInfo = kThinkCStackBased
  768.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32)))
  769.         | RESULT_SIZE(SIZE_CODE(sizeof(uint32)))
  770. };
  771.  
  772. #define NewNPN_MemFlushProc(FUNC)        \
  773.         (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture())
  774. #define CallNPN_MemFlushProc(FUNC, ARG1)        \
  775.         (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1))    
  776.  
  777. #else
  778.  
  779. typedef uint32 (*NPN_MemFlushUPP)(uint32 size);
  780. #define NewNPN_MemFlushProc(FUNC)        \
  781.         ((NPN_MemFlushUPP) (FUNC))
  782. #define CallNPN_MemFlushProc(FUNC, ARG1)        \
  783.         (*(FUNC))((ARG1))    
  784.  
  785. #endif
  786.  
  787.  
  788.  
  789. /* NPN_ReloadPlugins */
  790.  
  791. #if GENERATINGCFM
  792.  
  793. typedef UniversalProcPtr NPN_ReloadPluginsUPP;
  794. enum {
  795.     uppNPN_ReloadPluginsProcInfo = kThinkCStackBased
  796.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool)))
  797.         | RESULT_SIZE(SIZE_CODE(0))
  798. };
  799.  
  800. #define NewNPN_ReloadPluginsProc(FUNC)        \
  801.         (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture())
  802. #define CallNPN_ReloadPluginsProc(FUNC, ARG1)        \
  803.         (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1))    
  804.  
  805. #else
  806.  
  807. typedef void (*NPN_ReloadPluginsUPP)(NPBool reloadPages);
  808. #define NewNPN_ReloadPluginsProc(FUNC)        \
  809.         ((NPN_ReloadPluginsUPP) (FUNC))
  810. #define CallNPN_ReloadPluginsProc(FUNC, ARG1)        \
  811.         (*(FUNC))((ARG1))    
  812.  
  813. #endif
  814.  
  815.  
  816. /* NPN_GetJavaEnv */
  817.  
  818. #if GENERATINGCFM
  819.  
  820. typedef UniversalProcPtr NPN_GetJavaEnvUPP;
  821. enum {
  822.     uppNPN_GetJavaEnvProcInfo = kThinkCStackBased
  823.         | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*)))
  824. };
  825.  
  826. #define NewNPN_GetJavaEnvProc(FUNC)        \
  827.         (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture())
  828. #define CallNPN_GetJavaEnvProc(FUNC)        \
  829.         (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo)    
  830.  
  831. #else
  832.  
  833. typedef JRIEnv* (*NPN_GetJavaEnvUPP)(void);
  834. #define NewNPN_GetJavaEnvProc(FUNC)        \
  835.         ((NPN_GetJavaEnvUPP) (FUNC))
  836. #define CallNPN_GetJavaEnvProc(FUNC)        \
  837.         (*(FUNC))()    
  838.  
  839. #endif
  840.  
  841.  
  842. /* NPN_GetJavaPeer */
  843.  
  844. #if GENERATINGCFM
  845.  
  846. typedef UniversalProcPtr NPN_GetJavaPeerUPP;
  847. enum {
  848.     uppNPN_GetJavaPeerProcInfo = kThinkCStackBased
  849.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP)))
  850.         | RESULT_SIZE(SIZE_CODE(sizeof(jref)))
  851. };
  852.  
  853. #define NewNPN_GetJavaPeerProc(FUNC)        \
  854.         (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture())
  855. #define CallNPN_GetJavaPeerProc(FUNC, ARG1)        \
  856.         (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1))    
  857.  
  858. #else
  859.  
  860. typedef jref (*NPN_GetJavaPeerUPP)(NPP instance);
  861. #define NewNPN_GetJavaPeerProc(FUNC)        \
  862.         ((NPN_GetJavaPeerUPP) (FUNC))
  863. #define CallNPN_GetJavaPeerProc(FUNC, ARG1)        \
  864.         (*(FUNC))((ARG1))    
  865.  
  866. #endif
  867.  
  868.  
  869.  
  870.  
  871. /******************************************************************************************
  872.  * The actual plugin function table definitions
  873.  *******************************************************************************************/
  874.  
  875. typedef struct _NPPluginFuncs {
  876.     uint16 size;
  877.     uint16 version;
  878.     NPP_NewUPP newp;
  879.     NPP_DestroyUPP destroy;
  880.     NPP_SetWindowUPP setwindow;
  881.     NPP_NewStreamUPP newstream;
  882.     NPP_DestroyStreamUPP destroystream;
  883.     NPP_StreamAsFileUPP asfile;
  884.     NPP_WriteReadyUPP writeready;
  885.     NPP_WriteUPP write;
  886.     NPP_PrintUPP print;
  887.     NPP_HandleEventUPP event;
  888.     NPP_URLNotifyUPP urlnotify;
  889.     JRIGlobalRef javaClass;
  890. } NPPluginFuncs;
  891.  
  892. typedef struct _NPNetscapeFuncs {
  893.     uint16 size;
  894.     uint16 version;
  895.     NPN_GetURLUPP geturl;
  896.     NPN_PostURLUPP posturl;
  897.     NPN_RequestReadUPP requestread;
  898.     NPN_NewStreamUPP newstream;
  899.     NPN_WriteUPP write;
  900.     NPN_DestroyStreamUPP destroystream;
  901.     NPN_StatusUPP status;
  902.     NPN_UserAgentUPP uagent;
  903.     NPN_MemAllocUPP memalloc;
  904.     NPN_MemFreeUPP memfree;
  905.     NPN_MemFlushUPP memflush;
  906.     NPN_ReloadPluginsUPP reloadplugins;
  907.     NPN_GetJavaEnvUPP getJavaEnv;
  908.     NPN_GetJavaPeerUPP getJavaPeer;
  909.     NPN_GetURLNotifyUPP geturlnotify;
  910.     NPN_PostURLNotifyUPP posturlnotify;
  911. #ifdef XP_UNIX
  912.     NPN_GetValueUPP getvalue;
  913. #endif /* XP_UNIX */
  914. } NPNetscapeFuncs;
  915.  
  916.  
  917.  
  918. #ifdef XP_MAC
  919. /******************************************************************************************
  920.  * Mac platform-specific plugin glue stuff
  921.  *******************************************************************************************/
  922.  
  923. /*
  924.  * Main entry point of the plugin.
  925.  * This routine will be called when the plugin is loaded. The function
  926.  * tables are passed in and the plugin fills in the NPPluginFuncs table
  927.  * and NPPShutdownUPP for Netscape's use.
  928.  */
  929.  
  930. #if GENERATINGCFM
  931.  
  932. typedef UniversalProcPtr NPP_MainEntryUPP;
  933. enum {
  934.     uppNPP_MainEntryProcInfo = kThinkCStackBased
  935.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*)))
  936.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*)))
  937.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*)))
  938.         | RESULT_SIZE(SIZE_CODE(sizeof(NPError)))
  939. };
  940. #define NewNPP_MainEntryProc(FUNC)        \
  941.         (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture())
  942. #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)        \
  943.         CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP))
  944.  
  945. #else
  946.  
  947. typedef NPError (*NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*);
  948. #define NewNPP_MainEntryProc(FUNC)        \
  949.         ((NPP_MainEntryUPP) (FUNC))
  950. #define CallNPP_MainEntryProc(FUNC,  netscapeFunc, pluginFunc, shutdownUPP)        \
  951.         (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP))
  952.  
  953. #endif
  954. #endif /* MAC */
  955.  
  956.  
  957. #ifdef _WINDOWS
  958.  
  959. #ifdef __cplusplus
  960. extern "C" {
  961. #endif
  962.  
  963. /* plugin meta member functions */
  964.  
  965. NPError WINAPI NP_GetEntryPoints(NPPluginFuncs* pFuncs);
  966.  
  967. NPError WINAPI NP_Initialize(NPNetscapeFuncs* pFuncs);
  968.  
  969. NPError WINAPI NP_Shutdown();
  970.  
  971. #ifdef __cplusplus
  972. }
  973. #endif
  974.  
  975. #endif /* _WINDOWS */
  976.  
  977. #ifdef XP_UNIX
  978.  
  979. #ifdef __cplusplus
  980. extern "C" {
  981. #endif
  982.  
  983. /* plugin meta member functions */
  984.  
  985. char*    NP_GetMIMEDescription(void);
  986. NPError    NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*);
  987. NPError    NP_Shutdown(void);
  988.  
  989. #ifdef __cplusplus
  990. }
  991. #endif
  992.  
  993. #endif /* XP_UNIX */
  994.  
  995. #endif /* _NPUPP_H_ */
  996.